home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / swingall.jar / javax / swing / plaf / basic / BasicTreeUI.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-07-15  |  35.6 KB  |  1,500 lines
  1. package javax.swing.plaf.basic;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Component;
  5. import java.awt.Dimension;
  6. import java.awt.Graphics;
  7. import java.awt.Insets;
  8. import java.awt.Point;
  9. import java.awt.Rectangle;
  10. import java.awt.event.ActionListener;
  11. import java.awt.event.ComponentListener;
  12. import java.awt.event.FocusListener;
  13. import java.awt.event.InputEvent;
  14. import java.awt.event.KeyListener;
  15. import java.awt.event.MouseEvent;
  16. import java.awt.event.MouseListener;
  17. import java.beans.PropertyChangeListener;
  18. import java.util.Enumeration;
  19. import java.util.Hashtable;
  20. import java.util.Vector;
  21. import javax.swing.CellRendererPane;
  22. import javax.swing.Icon;
  23. import javax.swing.JComponent;
  24. import javax.swing.JTree;
  25. import javax.swing.KeyStroke;
  26. import javax.swing.SwingUtilities;
  27. import javax.swing.UIManager;
  28. import javax.swing.event.CellEditorListener;
  29. import javax.swing.event.TreeExpansionListener;
  30. import javax.swing.event.TreeModelListener;
  31. import javax.swing.event.TreeSelectionListener;
  32. import javax.swing.plaf.ComponentUI;
  33. import javax.swing.plaf.TreeUI;
  34. import javax.swing.plaf.UIResource;
  35. import javax.swing.tree.AbstractLayoutCache;
  36. import javax.swing.tree.DefaultTreeCellEditor;
  37. import javax.swing.tree.DefaultTreeCellRenderer;
  38. import javax.swing.tree.FixedHeightLayoutCache;
  39. import javax.swing.tree.TreeCellEditor;
  40. import javax.swing.tree.TreeCellRenderer;
  41. import javax.swing.tree.TreeModel;
  42. import javax.swing.tree.TreePath;
  43. import javax.swing.tree.TreeSelectionModel;
  44. import javax.swing.tree.VariableHeightLayoutCache;
  45.  
  46. public class BasicTreeUI extends TreeUI {
  47.    private static final Insets EMPTY_INSETS = new Insets(0, 0, 0, 0);
  48.    protected transient Icon collapsedIcon;
  49.    protected transient Icon expandedIcon;
  50.    private Color hashColor;
  51.    protected int leftChildIndent;
  52.    protected int rightChildIndent;
  53.    protected int totalChildIndent;
  54.    protected Dimension preferredMinSize;
  55.    protected int lastSelectedRow;
  56.    protected JTree tree;
  57.    protected transient TreeCellRenderer currentCellRenderer;
  58.    protected boolean createdRenderer;
  59.    protected transient TreeCellEditor cellEditor;
  60.    protected boolean createdCellEditor;
  61.    protected boolean stopEditingInCompleteEditing;
  62.    protected CellRendererPane rendererPane;
  63.    protected Dimension preferredSize;
  64.    protected boolean validCachedPreferredSize;
  65.    protected AbstractLayoutCache treeState;
  66.    protected Hashtable drawingCache;
  67.    protected boolean largeModel;
  68.    protected AbstractLayoutCache.NodeDimensions nodeDimensions;
  69.    protected TreeModel treeModel;
  70.    protected TreeSelectionModel treeSelectionModel;
  71.    protected int depthOffset;
  72.    protected Component editingComponent;
  73.    protected TreePath editingPath;
  74.    protected int editingRow;
  75.    protected boolean editorHasDifferentSize;
  76.    private TreePath anchorPath;
  77.    private TreePath leadPath;
  78.    private int leadRow;
  79.    private boolean changeSelectionWithFocus;
  80.    private Vector keyActions;
  81.    private PropertyChangeListener propertyChangeListener;
  82.    private PropertyChangeListener selectionModelPropertyChangeListener;
  83.    private MouseListener mouseListener;
  84.    private FocusListener focusListener;
  85.    private KeyListener keyListener;
  86.    private ComponentListener componentListener;
  87.    private CellEditorListener cellEditorListener;
  88.    private TreeSelectionListener treeSelectionListener;
  89.    private TreeModelListener treeModelListener;
  90.    private TreeExpansionListener treeExpansionListener;
  91.  
  92.    // $FF: synthetic method
  93.    static void access$0(BasicTreeUI var0) {
  94.       var0.updateLeadRow();
  95.    }
  96.  
  97.    // $FF: synthetic method
  98.    static TreePath access$1(BasicTreeUI var0) {
  99.       return var0.leadPath;
  100.    }
  101.  
  102.    // $FF: synthetic method
  103.    static void access$2(BasicTreeUI var0, TreePath var1) {
  104.       var0.setAnchorPath(var1);
  105.    }
  106.  
  107.    // $FF: synthetic method
  108.    static void access$3(BasicTreeUI var0, TreePath var1) {
  109.       var0.setLeadPath(var1);
  110.    }
  111.  
  112.    // $FF: synthetic method
  113.    static TreePath access$4(BasicTreeUI var0) {
  114.       return var0.getLeadPath();
  115.    }
  116.  
  117.    // $FF: synthetic method
  118.    static int access$5(BasicTreeUI var0) {
  119.       return var0.getLeadRow();
  120.    }
  121.  
  122.    // $FF: synthetic method
  123.    static void access$6(BasicTreeUI var0, TreePath var1, boolean var2) {
  124.       var0.setLeadPath(var1, var2);
  125.    }
  126.  
  127.    // $FF: synthetic method
  128.    static void access$7(BasicTreeUI var0, TreePath var1) {
  129.       var0.extendSelection(var1);
  130.    }
  131.  
  132.    // $FF: synthetic method
  133.    static boolean access$8(BasicTreeUI var0) {
  134.       return var0.changeSelectionWithFocus();
  135.    }
  136.  
  137.    // $FF: synthetic method
  138.    static TreePath access$9(BasicTreeUI var0) {
  139.       return var0.getAnchorPath();
  140.    }
  141.  
  142.    public void cancelEditing(JTree var1) {
  143.       if (this.editingComponent != null) {
  144.          this.completeEditing(false, true, false);
  145.       }
  146.  
  147.    }
  148.  
  149.    private boolean changeSelectionWithFocus() {
  150.       return this.changeSelectionWithFocus;
  151.    }
  152.  
  153.    protected void checkForClickInExpandControl(TreePath var1, int var2, int var3) {
  154.       if (this.isLocationInExpandControl(var1, var2, var3)) {
  155.          this.handleExpandControlClick(var1, var2, var3);
  156.       }
  157.  
  158.    }
  159.  
  160.    protected void completeEditing() {
  161.       if (this.tree.getInvokesStopCellEditing() && this.stopEditingInCompleteEditing && this.editingComponent != null) {
  162.          this.cellEditor.stopCellEditing();
  163.       }
  164.  
  165.       this.completeEditing(false, true, false);
  166.    }
  167.  
  168.    protected void completeEditing(boolean var1, boolean var2, boolean var3) {
  169.       if (this.stopEditingInCompleteEditing && this.editingComponent != null) {
  170.          Component var4 = this.editingComponent;
  171.          TreePath var5 = this.editingPath;
  172.          TreeCellEditor var6 = this.cellEditor;
  173.          Object var7 = var6.getCellEditorValue();
  174.          Rectangle var8 = this.getPathBounds(this.tree, this.editingPath);
  175.          boolean var9 = this.tree != null && (this.tree.hasFocus() || SwingUtilities.findFocusOwner(this.editingComponent) != null);
  176.          this.editingComponent = null;
  177.          this.editingPath = null;
  178.          if (var1) {
  179.             var6.stopCellEditing();
  180.          } else if (var2) {
  181.             var6.cancelCellEditing();
  182.          }
  183.  
  184.          this.tree.remove(var4);
  185.          if (this.editorHasDifferentSize) {
  186.             this.treeState.invalidatePathBounds(var5);
  187.             this.updateSize();
  188.          } else {
  189.             var8.x = 0;
  190.             var8.width = this.tree.getSize().width;
  191.             this.tree.repaint(var8);
  192.          }
  193.  
  194.          if (var9) {
  195.             this.tree.requestFocus();
  196.          }
  197.  
  198.          if (var3) {
  199.             this.treeModel.valueForPathChanged(var5, var7);
  200.          }
  201.       }
  202.  
  203.    }
  204.  
  205.    protected void completeUIInstall() {
  206.       this.setShowsRootHandles(this.tree.getShowsRootHandles());
  207.       this.updateRenderer();
  208.       this.updateDepthOffset();
  209.       this.setSelectionModel(this.tree.getSelectionModel());
  210.       this.treeState = this.createLayoutCache();
  211.       this.configureLayoutCache();
  212.       this.updateSize();
  213.    }
  214.  
  215.    protected void completeUIUninstall() {
  216.       if (this.createdRenderer) {
  217.          this.tree.setCellRenderer((TreeCellRenderer)null);
  218.       }
  219.  
  220.       if (this.createdCellEditor) {
  221.          this.tree.setCellEditor((TreeCellEditor)null);
  222.       }
  223.  
  224.       this.cellEditor = null;
  225.       this.currentCellRenderer = null;
  226.       this.rendererPane = null;
  227.       this.componentListener = null;
  228.       this.propertyChangeListener = null;
  229.       this.mouseListener = null;
  230.       this.focusListener = null;
  231.       this.keyListener = null;
  232.       this.treeState = null;
  233.       this.setSelectionModel((TreeSelectionModel)null);
  234.       this.drawingCache = null;
  235.       this.selectionModelPropertyChangeListener = null;
  236.       this.tree = null;
  237.       this.treeModel = null;
  238.       this.treeSelectionModel = null;
  239.       this.treeSelectionListener = null;
  240.       this.treeExpansionListener = null;
  241.    }
  242.  
  243.    protected void configureLayoutCache() {
  244.       if (this.treeState != null && this.tree != null) {
  245.          if (this.nodeDimensions == null) {
  246.             this.nodeDimensions = this.createNodeDimensions();
  247.          }
  248.  
  249.          this.treeState.setNodeDimensions(this.nodeDimensions);
  250.          this.treeState.setRootVisible(this.tree.isRootVisible());
  251.          this.treeState.setRowHeight(this.tree.getRowHeight());
  252.          this.treeState.setSelectionModel(this.getSelectionModel());
  253.          if (this.treeState.getModel() != this.tree.getModel()) {
  254.             this.treeState.setModel(this.tree.getModel());
  255.          }
  256.  
  257.          this.updateLayoutCacheExpandedNodes();
  258.          if (this.isLargeModel()) {
  259.             if (this.componentListener == null) {
  260.                this.componentListener = this.createComponentListener();
  261.                if (this.componentListener != null) {
  262.                   this.tree.addComponentListener(this.componentListener);
  263.                }
  264.             }
  265.          } else if (this.componentListener != null) {
  266.             this.tree.removeComponentListener(this.componentListener);
  267.             this.componentListener = null;
  268.          }
  269.       } else if (this.componentListener != null) {
  270.          this.tree.removeComponentListener(this.componentListener);
  271.          this.componentListener = null;
  272.       }
  273.  
  274.    }
  275.  
  276.    protected CellEditorListener createCellEditorListener() {
  277.       return new CellEditorHandler(this);
  278.    }
  279.  
  280.    protected CellRendererPane createCellRendererPane() {
  281.       return new CellRendererPane();
  282.    }
  283.  
  284.    protected ComponentListener createComponentListener() {
  285.       return new ComponentHandler(this);
  286.    }
  287.  
  288.    protected TreeCellEditor createDefaultCellEditor() {
  289.       if (this.currentCellRenderer != null && this.currentCellRenderer instanceof DefaultTreeCellRenderer) {
  290.          DefaultTreeCellEditor var1 = new DefaultTreeCellEditor(this.tree, (DefaultTreeCellRenderer)this.currentCellRenderer);
  291.          return var1;
  292.       } else {
  293.          return new DefaultTreeCellEditor(this.tree, (DefaultTreeCellRenderer)null);
  294.       }
  295.    }
  296.  
  297.    protected TreeCellRenderer createDefaultCellRenderer() {
  298.       return new DefaultTreeCellRenderer();
  299.    }
  300.  
  301.    protected FocusListener createFocusListener() {
  302.       return new FocusHandler(this);
  303.    }
  304.  
  305.    protected KeyListener createKeyListener() {
  306.       return new KeyHandler(this);
  307.    }
  308.  
  309.    protected AbstractLayoutCache createLayoutCache() {
  310.       return (AbstractLayoutCache)(this.isLargeModel() && this.getRowHeight() > 0 ? new FixedHeightLayoutCache() : new VariableHeightLayoutCache());
  311.    }
  312.  
  313.    protected MouseListener createMouseListener() {
  314.       return new MouseHandler(this);
  315.    }
  316.  
  317.    protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
  318.       return new NodeDimensionsHandler(this);
  319.    }
  320.  
  321.    protected PropertyChangeListener createPropertyChangeListener() {
  322.       return new PropertyChangeHandler(this);
  323.    }
  324.  
  325.    protected PropertyChangeListener createSelectionModelPropertyChangeListener() {
  326.       return new SelectionModelPropertyChangeHandler(this);
  327.    }
  328.  
  329.    protected TreeExpansionListener createTreeExpansionListener() {
  330.       return new TreeExpansionHandler(this);
  331.    }
  332.  
  333.    protected TreeModelListener createTreeModelListener() {
  334.       return new TreeModelHandler(this);
  335.    }
  336.  
  337.    protected TreeSelectionListener createTreeSelectionListener() {
  338.       return new TreeSelectionHandler(this);
  339.    }
  340.  
  341.    public static ComponentUI createUI(JComponent var0) {
  342.       return new BasicTreeUI();
  343.    }
  344.  
  345.    protected void drawCentered(Component var1, Graphics var2, Icon var3, int var4, int var5) {
  346.       var3.paintIcon(var1, var2, var4 - var3.getIconWidth() / 2, var5 - var3.getIconHeight() / 2);
  347.    }
  348.  
  349.    protected void drawDashedHorizontalLine(Graphics var1, int var2, int var3, int var4) {
  350.       var3 += var3 % 2;
  351.  
  352.       for(int var5 = var3; var5 <= var4; var5 += 2) {
  353.          var1.drawLine(var5, var2, var5, var2);
  354.       }
  355.  
  356.    }
  357.  
  358.    protected void drawDashedVerticalLine(Graphics var1, int var2, int var3, int var4) {
  359.       var3 += var3 % 2;
  360.  
  361.       for(int var5 = var3; var5 <= var4; var5 += 2) {
  362.          var1.drawLine(var2, var5, var2, var5);
  363.       }
  364.  
  365.    }
  366.  
  367.    protected void ensureRowsAreVisible(int var1, int var2) {
  368.       if (this.tree != null && var1 >= 0 && var2 < this.getRowCount(this.tree)) {
  369.          if (var1 == var2) {
  370.             Rectangle var3 = this.getPathBounds(this.tree, this.getPathForRow(this.tree, var1));
  371.             if (var3 != null) {
  372.                var3.width += var3.x;
  373.                var3.x = 0;
  374.                this.tree.scrollRectToVisible(var3);
  375.             }
  376.          } else {
  377.             Rectangle var9 = this.getPathBounds(this.tree, this.getPathForRow(this.tree, var1));
  378.             Rectangle var4 = this.tree.getVisibleRect();
  379.             Rectangle var5 = var9;
  380.             int var6 = var9.y;
  381.             int var7 = var6 + var4.height;
  382.  
  383.             for(int var8 = var1 + 1; var8 <= var2; ++var8) {
  384.                var5 = this.getPathBounds(this.tree, this.getPathForRow(this.tree, var8));
  385.                if (var5.y + var5.height > var7) {
  386.                   var8 = var2;
  387.                }
  388.             }
  389.  
  390.             this.tree.scrollRectToVisible(new Rectangle(var4.x, var6, 1, var5.y + var5.height - var6));
  391.          }
  392.       }
  393.  
  394.    }
  395.  
  396.    private void extendSelection(TreePath var1) {
  397.       TreePath var2 = this.getAnchorPath();
  398.       int var3 = var2 == null ? -1 : this.getRowForPath(this.tree, var2);
  399.       int var4 = this.getRowForPath(this.tree, var1);
  400.       if (var3 == -1) {
  401.          this.tree.setSelectionRow(var4);
  402.       } else {
  403.          if (var3 < var4) {
  404.             this.tree.setSelectionInterval(var3, var4);
  405.          } else {
  406.             this.tree.setSelectionInterval(var4, var3);
  407.          }
  408.  
  409.          this.setAnchorPath(var2);
  410.          this.setLeadPath(var1);
  411.       }
  412.  
  413.    }
  414.  
  415.    private TreePath getAnchorPath() {
  416.       return this.anchorPath;
  417.    }
  418.  
  419.    protected TreeCellEditor getCellEditor() {
  420.       return this.tree != null ? this.tree.getCellEditor() : null;
  421.    }
  422.  
  423.    protected TreeCellRenderer getCellRenderer() {
  424.       return this.currentCellRenderer;
  425.    }
  426.  
  427.    public TreePath getClosestPathForLocation(JTree var1, int var2, int var3) {
  428.       if (var1 != null && this.treeState != null) {
  429.          Insets var4 = ((JComponent)var1).getInsets();
  430.          if (var4 == null) {
  431.             var4 = EMPTY_INSETS;
  432.          }
  433.  
  434.          return this.treeState.getPathClosestTo(var2 - var4.left, var3 - var4.top);
  435.       } else {
  436.          return null;
  437.       }
  438.    }
  439.  
  440.    public Icon getCollapsedIcon() {
  441.       return this.collapsedIcon;
  442.    }
  443.  
  444.    public TreePath getEditingPath(JTree var1) {
  445.       return this.editingPath;
  446.    }
  447.  
  448.    public Icon getExpandedIcon() {
  449.       return this.expandedIcon;
  450.    }
  451.  
  452.    protected Color getHashColor() {
  453.       return this.hashColor;
  454.    }
  455.  
  456.    protected int getHorizontalLegBuffer() {
  457.       return 0;
  458.    }
  459.  
  460.    protected TreePath getLastChildPath(TreePath var1) {
  461.       if (this.treeModel != null) {
  462.          int var2 = this.treeModel.getChildCount(var1.getLastPathComponent());
  463.          if (var2 > 0) {
  464.             return var1.pathByAddingChild(this.treeModel.getChild(var1.getLastPathComponent(), var2 - 1));
  465.          }
  466.       }
  467.  
  468.       return null;
  469.    }
  470.  
  471.    private TreePath getLeadPath() {
  472.       return this.leadPath;
  473.    }
  474.  
  475.    private int getLeadRow() {
  476.       return this.leadRow;
  477.    }
  478.  
  479.    public int getLeftChildIndent() {
  480.       return this.leftChildIndent;
  481.    }
  482.  
  483.    public Dimension getMaximumSize(JComponent var1) {
  484.       if (this.tree != null) {
  485.          return this.getPreferredSize(this.tree);
  486.       } else {
  487.          return this.getPreferredMinSize() != null ? this.getPreferredMinSize() : new Dimension(0, 0);
  488.       }
  489.    }
  490.  
  491.    public Dimension getMinimumSize(JComponent var1) {
  492.       return this.getPreferredMinSize() != null ? this.getPreferredMinSize() : new Dimension(0, 0);
  493.    }
  494.  
  495.    protected TreeModel getModel() {
  496.       return this.treeModel;
  497.    }
  498.  
  499.    public Rectangle getPathBounds(JTree var1, TreePath var2) {
  500.       if (var1 != null && this.treeState != null) {
  501.          Insets var3 = ((JComponent)var1).getInsets();
  502.          Rectangle var4 = this.treeState.getBounds(var2, (Rectangle)null);
  503.          if (var4 != null && var3 != null) {
  504.             var4.x += var3.left;
  505.             var4.y += var3.top;
  506.          }
  507.  
  508.          return var4;
  509.       } else {
  510.          return null;
  511.       }
  512.    }
  513.  
  514.    public TreePath getPathForRow(JTree var1, int var2) {
  515.       return this.treeState != null ? this.treeState.getPathForRow(var2) : null;
  516.    }
  517.  
  518.    public Dimension getPreferredMinSize() {
  519.       return this.preferredMinSize == null ? null : new Dimension(this.preferredMinSize);
  520.    }
  521.  
  522.    public Dimension getPreferredSize(JComponent var1) {
  523.       return this.getPreferredSize(var1, true);
  524.    }
  525.  
  526.    public Dimension getPreferredSize(JComponent var1, boolean var2) {
  527.       Dimension var3 = this.getPreferredMinSize();
  528.       if (!this.validCachedPreferredSize) {
  529.          this.updateCachedPreferredSize();
  530.       }
  531.  
  532.       if (this.tree != null) {
  533.          return var3 != null ? new Dimension(Math.max(var3.width, this.preferredSize.width), Math.max(var3.height, this.preferredSize.height)) : new Dimension(this.preferredSize.width, this.preferredSize.height);
  534.       } else {
  535.          return var3 != null ? var3 : new Dimension(0, 0);
  536.       }
  537.    }
  538.  
  539.    public int getRightChildIndent() {
  540.       return this.rightChildIndent;
  541.    }
  542.  
  543.    public int getRowCount(JTree var1) {
  544.       return this.treeState != null ? this.treeState.getRowCount() : 0;
  545.    }
  546.  
  547.    public int getRowForPath(JTree var1, TreePath var2) {
  548.       return this.treeState != null ? this.treeState.getRowForPath(var2) : -1;
  549.    }
  550.  
  551.    protected int getRowHeight() {
  552.       return this.tree == null ? -1 : this.tree.getRowHeight();
  553.    }
  554.  
  555.    protected TreeSelectionModel getSelectionModel() {
  556.       return this.treeSelectionModel;
  557.    }
  558.  
  559.    protected boolean getShowsRootHandles() {
  560.       return this.tree != null ? this.tree.getShowsRootHandles() : false;
  561.    }
  562.  
  563.    protected int getVerticalLegBuffer() {
  564.       return 0;
  565.    }
  566.  
  567.    protected void handleExpandControlClick(TreePath var1, int var2, int var3) {
  568.       this.toggleExpandState(var1);
  569.    }
  570.  
  571.    protected void installComponents() {
  572.       if ((this.rendererPane = this.createCellRendererPane()) != null) {
  573.          this.tree.add(this.rendererPane);
  574.       }
  575.  
  576.    }
  577.  
  578.    protected void installDefaults() {
  579.       if (this.tree.getBackground() == null || this.tree.getBackground() instanceof UIResource) {
  580.          this.tree.setBackground(UIManager.getColor("Tree.background"));
  581.       }
  582.  
  583.       if (this.getHashColor() == null || this.getHashColor() instanceof UIResource) {
  584.          this.setHashColor(UIManager.getColor("Tree.hash"));
  585.       }
  586.  
  587.       if (this.tree.getFont() == null || this.tree.getFont() instanceof UIResource) {
  588.          this.tree.setFont(UIManager.getFont("Tree.font"));
  589.       }
  590.  
  591.       this.setExpandedIcon((Icon)UIManager.get("Tree.expandedIcon"));
  592.       this.setCollapsedIcon((Icon)UIManager.get("Tree.collapsedIcon"));
  593.       this.setLeftChildIndent((Integer)UIManager.get("Tree.leftChildIndent"));
  594.       this.setRightChildIndent((Integer)UIManager.get("Tree.rightChildIndent"));
  595.       this.changeSelectionWithFocus = (Boolean)UIManager.get("Tree.changeSelectionWithFocus");
  596.    }
  597.  
  598.    protected void installKeyboardActions() {
  599.       boolean var1 = this.changeSelectionWithFocus();
  600.       this.keyActions = new Vector(43);
  601.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, -1, "UP", false, var1), KeyStroke.getKeyStroke(38, 0));
  602.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, -1, "UP", false, var1), KeyStroke.getKeyStroke("KP_UP"));
  603.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, -1, "SELECT_UP", true, true), KeyStroke.getKeyStroke(38, 1));
  604.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, -1, "SELECT_UP", true, true), KeyStroke.getKeyStroke("shift KP_UP"));
  605.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, 1, "DOWN", false, var1), KeyStroke.getKeyStroke(40, 0));
  606.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, 1, "DOWN", false, var1), KeyStroke.getKeyStroke("KP_DOWN"));
  607.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, 1, "SELECT_DOWN", true, true), KeyStroke.getKeyStroke(40, 1));
  608.       this.registerKeyAction(new TreeIncrementAction(this, (1)null, 1, "SELECT_DOWN", true, true), KeyStroke.getKeyStroke("shift KP_DOWN"));
  609.       this.registerKeyAction(new TreeTraverseAction(this, (1)null, 1, "RIGHT", var1), KeyStroke.getKeyStroke(39, 0));
  610.       this.registerKeyAction(new TreeTraverseAction(this, (1)null, 1, "RIGHT", var1), KeyStroke.getKeyStroke("KP_RIGHT"));
  611.       this.registerKeyAction(new TreeTraverseAction(this, (1)null, -1, "LEFT", var1), KeyStroke.getKeyStroke(37, 0));
  612.       this.registerKeyAction(new TreeTraverseAction(this, (1)null, -1, "LEFT", var1), KeyStroke.getKeyStroke("KP_LEFT"));
  613.       this.registerKeyAction(new TreePageAction(this, (1)null, -1, "P_UP", false, var1), KeyStroke.getKeyStroke(33, 0));
  614.       this.registerKeyAction(new TreePageAction(this, (1)null, -1, "SELECT_P_UP", true, true), KeyStroke.getKeyStroke(33, 1));
  615.       this.registerKeyAction(new TreePageAction(this, (1)null, 1, "P_DOWN", false, var1), KeyStroke.getKeyStroke(34, 0));
  616.       this.registerKeyAction(new TreePageAction(this, (1)null, 1, "SELECT_P_DOWN", true, true), KeyStroke.getKeyStroke(34, 1));
  617.       this.registerKeyAction(new TreeHomeAction(this, (1)null, -1, "HOME", false, var1), KeyStroke.getKeyStroke(36, 0));
  618.       this.registerKeyAction(new TreeHomeAction(this, (1)null, -1, "SELECT_HOME", true, true), KeyStroke.getKeyStroke(36, 1));
  619.       this.registerKeyAction(new TreeHomeAction(this, (1)null, 1, "END", false, var1), KeyStroke.getKeyStroke(35, 0));
  620.       this.registerKeyAction(new TreeHomeAction(this, (1)null, 1, "SELECT_END", true, true), KeyStroke.getKeyStroke(35, 1));
  621.       this.registerKeyAction(new TreeToggleAction(this, "TOGGLE"), KeyStroke.getKeyStroke(10, 0));
  622.       KeyStroke var2 = KeyStroke.getKeyStroke(27, 0);
  623.       this.tree.registerKeyboardAction(new TreeCancelEditingAction(this, "ESCAPE"), var2, 1);
  624.       this.keyActions.addElement(var2);
  625.       this.registerKeyAction(new TreeEditAction(this, "EDIT_NODE"), KeyStroke.getKeyStroke(113, 0));
  626.       TreeSelectAllAction var3 = new TreeSelectAllAction(this, "SELECT_ALL", true);
  627.       this.registerKeyAction(var3, KeyStroke.getKeyStroke(65, 2));
  628.       this.registerKeyAction(var3, KeyStroke.getKeyStroke(47, 2));
  629.       this.registerKeyAction(new TreeSelectAllAction(this, "UNSELECT_ALL", false), KeyStroke.getKeyStroke(92, 2));
  630.       this.registerKeyAction(new TreeAddSelectionAction(this, "SELECT_NODE", false), KeyStroke.getKeyStroke(32, 2));
  631.       this.registerKeyAction(new TreeExtendSelectionAction(this, "EXTEND_SELECTION"), KeyStroke.getKeyStroke(32, 1));
  632.       if (var1) {
  633.          this.registerKeyAction(new TreeHomeAction(this, (1)null, -1, "HOME", false, false), KeyStroke.getKeyStroke(36, 2));
  634.          this.registerKeyAction(new TreeHomeAction(this, (1)null, 1, "END", false, false), KeyStroke.getKeyStroke(35, 2));
  635.          this.registerKeyAction(new TreeIncrementAction(this, (1)null, -1, "UP", false, false), KeyStroke.getKeyStroke(38, 2));
  636.          this.registerKeyAction(new TreeIncrementAction(this, (1)null, -1, "UP", false, false), KeyStroke.getKeyStroke("ctrl KP_UP"));
  637.          this.registerKeyAction(new TreeIncrementAction(this, (1)null, 1, "DOWN", false, false), KeyStroke.getKeyStroke(40, 2));
  638.          this.registerKeyAction(new TreeIncrementAction(this, (1)null, 1, "DOWN", false, false), KeyStroke.getKeyStroke("ctrl KP_DOWN"));
  639.          this.registerKeyAction(new TreePageAction(this, (1)null, 1, "LEAD_P_DOWN", false, false), KeyStroke.getKeyStroke(34, 2));
  640.          this.registerKeyAction(new TreePageAction(this, (1)null, 1, "SELECT_P_DOWN", true, true), KeyStroke.getKeyStroke(34, 3));
  641.          this.registerKeyAction(new TreePageAction(this, (1)null, -1, "LEAD_P_UP", false, false), KeyStroke.getKeyStroke(33, 2));
  642.          this.registerKeyAction(new TreePageAction(this, (1)null, -1, "SELECT_P_UP", true, true), KeyStroke.getKeyStroke(33, 3));
  643.          this.registerKeyAction(new ScrollAction(this.tree, 0, -10), KeyStroke.getKeyStroke(37, 2));
  644.          this.registerKeyAction(new ScrollAction(this.tree, 0, -10), KeyStroke.getKeyStroke("ctrl KP_LEFT"));
  645.          this.registerKeyAction(new ScrollAction(this.tree, 0, 10), KeyStroke.getKeyStroke(39, 2));
  646.          this.registerKeyAction(new ScrollAction(this.tree, 0, 10), KeyStroke.getKeyStroke("ctrl KP_RIGHT"));
  647.          this.registerKeyAction(new TreeAddSelectionAction(this, "SELECT_NODE", false), KeyStroke.getKeyStroke(32, 0));
  648.       } else {
  649.          this.registerKeyAction(new TreeScrollLRAction(this, 1, "CTRL_P_DOWN", false), KeyStroke.getKeyStroke(34, 2));
  650.          this.registerKeyAction(new TreeScrollLRAction(this, -1, "CTRL_P_UP", false), KeyStroke.getKeyStroke(33, 2));
  651.          this.registerKeyAction(new TreeScrollLRAction(this, -1, "SELECT_CTRL_P_UP", true), KeyStroke.getKeyStroke(33, 3));
  652.          this.registerKeyAction(new TreeScrollLRAction(this, 1, "SELECT_CTRL_P_DOWN", true), KeyStroke.getKeyStroke(34, 3));
  653.          this.registerKeyAction(new TreeAddSelectionAction(this, "SELECT_NODE", true), KeyStroke.getKeyStroke(32, 0));
  654.       }
  655.  
  656.    }
  657.  
  658.    protected void installListeners() {
  659.       if ((this.propertyChangeListener = this.createPropertyChangeListener()) != null) {
  660.          this.tree.addPropertyChangeListener(this.propertyChangeListener);
  661.       }
  662.  
  663.       if ((this.mouseListener = this.createMouseListener()) != null) {
  664.          this.tree.addMouseListener(this.mouseListener);
  665.       }
  666.  
  667.       if ((this.focusListener = this.createFocusListener()) != null) {
  668.          this.tree.addFocusListener(this.focusListener);
  669.       }
  670.  
  671.       if ((this.keyListener = this.createKeyListener()) != null) {
  672.          this.tree.addKeyListener(this.keyListener);
  673.       }
  674.  
  675.       if ((this.treeExpansionListener = this.createTreeExpansionListener()) != null) {
  676.          this.tree.addTreeExpansionListener(this.treeExpansionListener);
  677.       }
  678.  
  679.       if ((this.treeModelListener = this.createTreeModelListener()) != null && this.treeModel != null) {
  680.          this.treeModel.addTreeModelListener(this.treeModelListener);
  681.       }
  682.  
  683.       if ((this.selectionModelPropertyChangeListener = this.createSelectionModelPropertyChangeListener()) != null && this.treeSelectionModel != null) {
  684.          this.treeSelectionModel.addPropertyChangeListener(this.selectionModelPropertyChangeListener);
  685.       }
  686.  
  687.       if ((this.treeSelectionListener = this.createTreeSelectionListener()) != null && this.treeSelectionModel != null) {
  688.          this.treeSelectionModel.addTreeSelectionListener(this.treeSelectionListener);
  689.       }
  690.  
  691.    }
  692.  
  693.    public void installUI(JComponent var1) {
  694.       if (var1 == null) {
  695.          throw new NullPointerException("null component passed to BasicTreeUI.installUI()");
  696.       } else {
  697.          this.tree = (JTree)var1;
  698.          this.prepareForUIInstall();
  699.          this.installDefaults();
  700.          this.installListeners();
  701.          this.installKeyboardActions();
  702.          this.installComponents();
  703.          this.completeUIInstall();
  704.       }
  705.    }
  706.  
  707.    protected boolean isEditable() {
  708.       return this.tree != null ? this.tree.isEditable() : false;
  709.    }
  710.  
  711.    public boolean isEditing(JTree var1) {
  712.       return this.editingComponent != null;
  713.    }
  714.  
  715.    protected boolean isLargeModel() {
  716.       return this.largeModel;
  717.    }
  718.  
  719.    protected boolean isLeaf(int var1) {
  720.       TreePath var2 = this.getPathForRow(this.tree, var1);
  721.       return var2 != null ? this.treeModel.isLeaf(var2.getLastPathComponent()) : true;
  722.    }
  723.  
  724.    protected boolean isLocationInExpandControl(TreePath var1, int var2, int var3) {
  725.       if (var1 != null && !this.treeModel.isLeaf(var1.getLastPathComponent())) {
  726.          Insets var5 = this.tree.getInsets();
  727.          int var4;
  728.          if (this.getExpandedIcon() != null) {
  729.             var4 = this.getExpandedIcon().getIconWidth();
  730.          } else {
  731.             var4 = 8;
  732.          }
  733.  
  734.          int var6 = var5 != null ? var5.left : 0;
  735.          var6 += (var1.getPathCount() + this.depthOffset - 2) * this.totalChildIndent + this.getLeftChildIndent() - var4 / 2;
  736.          int var7 = var6 + var4;
  737.          return var2 >= var6 && var2 <= var7;
  738.       } else {
  739.          return false;
  740.       }
  741.    }
  742.  
  743.    protected boolean isMultiSelectEvent(MouseEvent var1) {
  744.       return SwingUtilities.isLeftMouseButton(var1) && ((InputEvent)var1).isShiftDown();
  745.    }
  746.  
  747.    protected boolean isRootVisible() {
  748.       return this.tree != null ? this.tree.isRootVisible() : false;
  749.    }
  750.  
  751.    protected boolean isToggleEvent(MouseEvent var1) {
  752.       if (!SwingUtilities.isLeftMouseButton(var1)) {
  753.          return false;
  754.       } else {
  755.          byte var2 = 2;
  756.          if (var2 <= 0) {
  757.             return false;
  758.          } else {
  759.             return var1.getClickCount() == var2;
  760.          }
  761.       }
  762.    }
  763.  
  764.    protected boolean isToggleSelectionEvent(MouseEvent var1) {
  765.       return SwingUtilities.isLeftMouseButton(var1) && ((InputEvent)var1).isControlDown();
  766.    }
  767.  
  768.    public void paint(Graphics var1, JComponent var2) {
  769.       if (this.tree != var2) {
  770.          throw new InternalError("incorrect component");
  771.       } else if (this.treeState != null) {
  772.          Rectangle var3 = var1.getClipBounds();
  773.          Insets var4 = this.tree.getInsets();
  774.          if (var4 == null) {
  775.             var4 = EMPTY_INSETS;
  776.          }
  777.  
  778.          TreePath var5 = this.getClosestPathForLocation(this.tree, 0, var3.y);
  779.          Enumeration var6 = this.treeState.getVisiblePathsFrom(var5);
  780.          int var7 = this.treeState.getRowForPath(var5);
  781.          int var8 = var3.y + var3.height;
  782.          this.drawingCache.clear();
  783.          if (var5 != null && var6 != null) {
  784.             for(TreePath var9 = var5.getParentPath(); var9 != null; var9 = var9.getParentPath()) {
  785.                this.paintVerticalPartOfLeg(var1, var3, var4, var9);
  786.                this.drawingCache.put(var9, Boolean.TRUE);
  787.             }
  788.  
  789.             boolean var10 = false;
  790.             Rectangle var14 = new Rectangle();
  791.  
  792.             for(boolean var17 = this.isRootVisible(); !var10 && var6.hasMoreElements(); ++var7) {
  793.                TreePath var16 = (TreePath)var6.nextElement();
  794.                if (var16 != null) {
  795.                   boolean var13 = this.treeModel.isLeaf(var16.getLastPathComponent());
  796.                   boolean var11;
  797.                   boolean var12;
  798.                   if (var13) {
  799.                      var12 = false;
  800.                      var11 = false;
  801.                   } else {
  802.                      var11 = this.treeState.getExpandedState(var16);
  803.                      var12 = this.tree.hasBeenExpanded(var16);
  804.                   }
  805.  
  806.                   Rectangle var15 = this.treeState.getBounds(var16, var14);
  807.                   if (var15 == null) {
  808.                      return;
  809.                   }
  810.  
  811.                   var15.x += var4.left;
  812.                   var15.y += var4.top;
  813.                   TreePath var18 = var16.getParentPath();
  814.                   if (var18 != null) {
  815.                      if (this.drawingCache.get(var18) == null) {
  816.                         this.paintVerticalPartOfLeg(var1, var3, var4, var18);
  817.                         this.drawingCache.put(var18, Boolean.TRUE);
  818.                      }
  819.  
  820.                      this.paintHorizontalPartOfLeg(var1, var3, var4, var15, var16, var7, var11, var12, var13);
  821.                   } else if (var17 && var7 == 0) {
  822.                      this.paintHorizontalPartOfLeg(var1, var3, var4, var15, var16, var7, var11, var12, var13);
  823.                   }
  824.  
  825.                   if (this.shouldPaintExpandControl(var16, var7, var11, var12, var13)) {
  826.                      this.paintExpandControl(var1, var3, var4, var15, var16, var7, var11, var12, var13);
  827.                   }
  828.  
  829.                   this.paintRow(var1, var3, var4, var15, var16, var7, var11, var12, var13);
  830.                   if (var15.y + var15.height >= var8) {
  831.                      var10 = true;
  832.                   }
  833.                } else {
  834.                   var10 = true;
  835.                }
  836.             }
  837.          }
  838.  
  839.       }
  840.    }
  841.  
  842.    protected void paintExpandControl(Graphics var1, Rectangle var2, Insets var3, Rectangle var4, TreePath var5, int var6, boolean var7, boolean var8, boolean var9) {
  843.       Object var10 = var5.getLastPathComponent();
  844.       if (!var9 && (!var8 || this.treeModel.getChildCount(var10) > 0)) {
  845.          int var11 = var4.x - (this.getRightChildIndent() - 1);
  846.          int var12 = var4.y + var4.height / 2;
  847.          if (var7) {
  848.             Icon var13 = this.getExpandedIcon();
  849.             if (var13 != null) {
  850.                this.drawCentered(this.tree, var1, var13, var11, var12);
  851.             }
  852.          } else {
  853.             Icon var14 = this.getCollapsedIcon();
  854.             if (var14 != null) {
  855.                this.drawCentered(this.tree, var1, var14, var11, var12);
  856.             }
  857.          }
  858.       }
  859.  
  860.    }
  861.  
  862.    protected void paintHorizontalLine(Graphics var1, JComponent var2, int var3, int var4, int var5) {
  863.       var1.drawLine(var4, var3, var5, var3);
  864.    }
  865.  
  866.    protected void paintHorizontalPartOfLeg(Graphics var1, Rectangle var2, Insets var3, Rectangle var4, TreePath var5, int var6, boolean var7, boolean var8, boolean var9) {
  867.       int var10 = var2.x;
  868.       int var11 = var2.x + (var2.width - 1);
  869.       int var12 = var2.y;
  870.       int var13 = var2.y + (var2.height - 1);
  871.       int var14 = var4.y + var4.height / 2;
  872.       int var15 = var4.x - this.totalChildIndent + 8;
  873.       int var16 = var4.x - this.getHorizontalLegBuffer();
  874.       if (var14 > var12 && var14 < var13 && var16 > var10 && var15 < var11) {
  875.          var15 = Math.max(var15, var10);
  876.          var16 = Math.min(var16, var11);
  877.          var1.setColor(this.getHashColor());
  878.          this.paintHorizontalLine(var1, this.tree, var14, var15, var16);
  879.       }
  880.  
  881.    }
  882.  
  883.    protected void paintRow(Graphics var1, Rectangle var2, Insets var3, Rectangle var4, TreePath var5, int var6, boolean var7, boolean var8, boolean var9) {
  884.       if (this.editingComponent == null || this.editingRow != var6) {
  885.          int var10;
  886.          if (this.tree.hasFocus()) {
  887.             var10 = this.getLeadRow();
  888.          } else {
  889.             var10 = -1;
  890.          }
  891.  
  892.          Component var11 = this.currentCellRenderer.getTreeCellRendererComponent(this.tree, var5.getLastPathComponent(), this.tree.isRowSelected(var6), var7, var9, var6, var10 == var6);
  893.          this.rendererPane.paintComponent(var1, var11, this.tree, var4.x, var4.y, var4.width, var4.height, true);
  894.       }
  895.    }
  896.  
  897.    protected void paintVerticalLine(Graphics var1, JComponent var2, int var3, int var4, int var5) {
  898.       var1.drawLine(var3, var4, var3, var5);
  899.    }
  900.  
  901.    protected void paintVerticalPartOfLeg(Graphics var1, Rectangle var2, Insets var3, TreePath var4) {
  902.       int var5 = (var4.getPathCount() - 1 + this.depthOffset) * this.totalChildIndent + 8 + var3.left;
  903.       int var6 = var2.x;
  904.       int var7 = var2.x + (var2.width - 1);
  905.       if (var5 > var6 && var5 < var7) {
  906.          int var8 = var2.y;
  907.          int var9 = var2.y + var2.height;
  908.          Rectangle var10 = this.getPathBounds(this.tree, var4);
  909.          Rectangle var11 = this.getPathBounds(this.tree, this.getLastChildPath(var4));
  910.          if (var11 == null) {
  911.             return;
  912.          }
  913.  
  914.          int var12;
  915.          if (var10 == null) {
  916.             var12 = Math.max(var3.top + this.getVerticalLegBuffer(), var8);
  917.          } else {
  918.             var12 = Math.max(var10.y + var10.height + this.getVerticalLegBuffer(), var8);
  919.          }
  920.  
  921.          if (var4.getPathCount() == 1 && !this.isRootVisible()) {
  922.             TreeModel var13 = this.getModel();
  923.             if (var13 != null) {
  924.                Object var14 = var13.getRoot();
  925.                if (var13.getChildCount(var14) > 0) {
  926.                   var10 = this.getPathBounds(this.tree, var4.pathByAddingChild(var13.getChild(var14, 0)));
  927.                   if (var10 != null) {
  928.                      var12 = Math.max(var3.top + this.getVerticalLegBuffer(), var10.y + var10.height / 2);
  929.                   }
  930.                }
  931.             }
  932.          }
  933.  
  934.          int var16 = Math.min(var11.y + var11.height / 2, var9);
  935.          var1.setColor(this.getHashColor());
  936.          this.paintVerticalLine(var1, this.tree, var5, var12, var16);
  937.       }
  938.  
  939.    }
  940.  
  941.    protected void pathWasCollapsed(TreePath var1) {
  942.       if (this.tree != null) {
  943.          this.tree.fireTreeCollapsed(var1);
  944.       }
  945.  
  946.    }
  947.  
  948.    protected void pathWasExpanded(TreePath var1) {
  949.       if (this.tree != null) {
  950.          this.tree.fireTreeExpanded(var1);
  951.       }
  952.  
  953.    }
  954.  
  955.    protected void prepareForUIInstall() {
  956.       this.drawingCache = new Hashtable(7);
  957.       this.stopEditingInCompleteEditing = true;
  958.       this.lastSelectedRow = -1;
  959.       this.leadPath = this.anchorPath = null;
  960.       this.leadRow = -1;
  961.       this.preferredSize = new Dimension();
  962.       this.tree.setRowHeight(UIManager.getInt("Tree.rowHeight"));
  963.       Object var1 = UIManager.get("Tree.scrollsOnExpand");
  964.       if (var1 != null) {
  965.          this.tree.setScrollsOnExpand((Boolean)var1);
  966.       }
  967.  
  968.       this.largeModel = this.tree.isLargeModel();
  969.       if (this.getRowHeight() <= 0) {
  970.          this.largeModel = false;
  971.       }
  972.  
  973.       this.setModel(this.tree.getModel());
  974.    }
  975.  
  976.    protected void prepareForUIUninstall() {
  977.    }
  978.  
  979.    private void registerKeyAction(ActionListener var1, KeyStroke var2) {
  980.       this.keyActions.addElement(var2);
  981.       this.tree.registerKeyboardAction(var1, var2, 0);
  982.    }
  983.  
  984.    protected void selectPathForEvent(TreePath var1, MouseEvent var2) {
  985.       if (this.isToggleSelectionEvent(var2)) {
  986.          if (this.tree.isPathSelected(var1)) {
  987.             this.tree.removeSelectionPath(var1);
  988.          } else {
  989.             this.tree.addSelectionPath(var1);
  990.          }
  991.  
  992.          this.lastSelectedRow = this.getRowForPath(this.tree, var1);
  993.          this.setAnchorPath(var1);
  994.          this.setLeadPath(var1);
  995.       } else if (this.isMultiSelectEvent(var2)) {
  996.          TreePath var3 = this.getAnchorPath();
  997.          int var4 = var3 == null ? -1 : this.getRowForPath(this.tree, var3);
  998.          if (var4 == -1) {
  999.             this.tree.setSelectionPath(var1);
  1000.          } else {
  1001.             int var5 = this.getRowForPath(this.tree, var1);
  1002.             if (var5 < var4) {
  1003.                this.tree.setSelectionInterval(var5, var4);
  1004.             } else {
  1005.                this.tree.setSelectionInterval(var4, var5);
  1006.             }
  1007.  
  1008.             this.lastSelectedRow = var5;
  1009.             this.setAnchorPath(var3);
  1010.          }
  1011.       } else if (SwingUtilities.isLeftMouseButton(var2)) {
  1012.          this.tree.setSelectionPath(var1);
  1013.          if (this.isToggleEvent(var2)) {
  1014.             this.toggleExpandState(var1);
  1015.          }
  1016.       }
  1017.  
  1018.    }
  1019.  
  1020.    private void setAnchorPath(TreePath var1) {
  1021.       this.anchorPath = var1;
  1022.    }
  1023.  
  1024.    protected void setCellEditor(TreeCellEditor var1) {
  1025.       this.updateCellEditor();
  1026.    }
  1027.  
  1028.    protected void setCellRenderer(TreeCellRenderer var1) {
  1029.       this.completeEditing();
  1030.       this.updateRenderer();
  1031.       if (this.treeState != null) {
  1032.          this.treeState.invalidateSizes();
  1033.          this.updateSize();
  1034.       }
  1035.  
  1036.    }
  1037.  
  1038.    public void setCollapsedIcon(Icon var1) {
  1039.       this.collapsedIcon = var1;
  1040.    }
  1041.  
  1042.    protected void setEditable(boolean var1) {
  1043.       this.updateCellEditor();
  1044.    }
  1045.  
  1046.    public void setExpandedIcon(Icon var1) {
  1047.       this.expandedIcon = var1;
  1048.    }
  1049.  
  1050.    protected void setHashColor(Color var1) {
  1051.       this.hashColor = var1;
  1052.    }
  1053.  
  1054.    protected void setLargeModel(boolean var1) {
  1055.       if (this.getRowHeight() < 1) {
  1056.          var1 = false;
  1057.       }
  1058.  
  1059.       if (this.largeModel != var1) {
  1060.          this.completeEditing();
  1061.          this.largeModel = var1;
  1062.          this.treeState = this.createLayoutCache();
  1063.          this.configureLayoutCache();
  1064.          this.updateLayoutCacheExpandedNodes();
  1065.          this.updateSize();
  1066.       }
  1067.  
  1068.    }
  1069.  
  1070.    private void setLeadPath(TreePath var1) {
  1071.       this.setLeadPath(var1, false);
  1072.    }
  1073.  
  1074.    private void setLeadPath(TreePath var1, boolean var2) {
  1075.       Rectangle var3 = var2 ? this.getPathBounds(this.tree, this.leadPath) : null;
  1076.       this.leadPath = var1;
  1077.       this.leadRow = this.getRowForPath(this.tree, this.leadPath);
  1078.       if (var2) {
  1079.          if (var3 != null) {
  1080.             this.tree.repaint(var3);
  1081.          }
  1082.  
  1083.          var3 = this.getPathBounds(this.tree, this.leadPath);
  1084.          if (var3 != null) {
  1085.             this.tree.repaint(var3);
  1086.          }
  1087.       }
  1088.  
  1089.    }
  1090.  
  1091.    public void setLeftChildIndent(int var1) {
  1092.       this.leftChildIndent = var1;
  1093.       this.totalChildIndent = this.leftChildIndent + this.rightChildIndent;
  1094.       if (this.treeState != null) {
  1095.          this.treeState.invalidateSizes();
  1096.       }
  1097.  
  1098.       this.updateSize();
  1099.    }
  1100.  
  1101.    protected void setModel(TreeModel var1) {
  1102.       this.completeEditing();
  1103.       if (this.treeModel != null && this.treeModelListener != null) {
  1104.          this.treeModel.removeTreeModelListener(this.treeModelListener);
  1105.       }
  1106.  
  1107.       this.treeModel = var1;
  1108.       if (this.treeModel != null && this.treeModelListener != null) {
  1109.          this.treeModel.addTreeModelListener(this.treeModelListener);
  1110.       }
  1111.  
  1112.       if (this.treeState != null) {
  1113.          this.treeState.setModel(var1);
  1114.          this.updateLayoutCacheExpandedNodes();
  1115.          this.updateSize();
  1116.       }
  1117.  
  1118.    }
  1119.  
  1120.    public void setPreferredMinSize(Dimension var1) {
  1121.       this.preferredMinSize = var1;
  1122.    }
  1123.  
  1124.    public void setRightChildIndent(int var1) {
  1125.       this.rightChildIndent = var1;
  1126.       this.totalChildIndent = this.leftChildIndent + this.rightChildIndent;
  1127.       if (this.treeState != null) {
  1128.          this.treeState.invalidateSizes();
  1129.       }
  1130.  
  1131.       this.updateSize();
  1132.    }
  1133.  
  1134.    protected void setRootVisible(boolean var1) {
  1135.       this.completeEditing();
  1136.       this.updateDepthOffset();
  1137.       if (this.treeState != null) {
  1138.          this.treeState.setRootVisible(var1);
  1139.          this.treeState.invalidateSizes();
  1140.          this.updateSize();
  1141.       }
  1142.  
  1143.    }
  1144.  
  1145.    protected void setRowHeight(int var1) {
  1146.       this.completeEditing();
  1147.       if (this.treeState != null) {
  1148.          this.setLargeModel(this.tree.isLargeModel());
  1149.          this.treeState.setRowHeight(var1);
  1150.          this.updateSize();
  1151.       }
  1152.  
  1153.    }
  1154.  
  1155.    protected void setSelectionModel(TreeSelectionModel var1) {
  1156.       this.completeEditing();
  1157.       if (this.selectionModelPropertyChangeListener != null && this.treeSelectionModel != null) {
  1158.          this.treeSelectionModel.removePropertyChangeListener(this.selectionModelPropertyChangeListener);
  1159.       }
  1160.  
  1161.       if (this.treeSelectionListener != null && this.treeSelectionModel != null) {
  1162.          this.treeSelectionModel.removeTreeSelectionListener(this.treeSelectionListener);
  1163.       }
  1164.  
  1165.       this.treeSelectionModel = var1;
  1166.       if (this.treeSelectionModel != null) {
  1167.          if (this.selectionModelPropertyChangeListener != null) {
  1168.             this.treeSelectionModel.addPropertyChangeListener(this.selectionModelPropertyChangeListener);
  1169.          }
  1170.  
  1171.          if (this.treeSelectionListener != null) {
  1172.             this.treeSelectionModel.addTreeSelectionListener(this.treeSelectionListener);
  1173.          }
  1174.  
  1175.          if (this.treeState != null) {
  1176.             this.treeState.setSelectionModel(this.treeSelectionModel);
  1177.          }
  1178.       } else if (this.treeState != null) {
  1179.          this.treeState.setSelectionModel((TreeSelectionModel)null);
  1180.       }
  1181.  
  1182.       if (this.tree != null) {
  1183.          this.tree.repaint();
  1184.       }
  1185.  
  1186.    }
  1187.  
  1188.    protected void setShowsRootHandles(boolean var1) {
  1189.       this.completeEditing();
  1190.       this.updateDepthOffset();
  1191.       if (this.treeState != null) {
  1192.          this.treeState.invalidateSizes();
  1193.          this.updateSize();
  1194.       }
  1195.  
  1196.    }
  1197.  
  1198.    protected boolean shouldPaintExpandControl(TreePath var1, int var2, boolean var3, boolean var4, boolean var5) {
  1199.       if (var5) {
  1200.          return false;
  1201.       } else {
  1202.          int var6 = var1.getPathCount() - 1;
  1203.          return var6 != 0 && (var6 != 1 || this.isRootVisible()) || this.getShowsRootHandles();
  1204.       }
  1205.    }
  1206.  
  1207.    protected boolean startEditing(TreePath var1, MouseEvent var2) {
  1208.       this.completeEditing();
  1209.       if (this.cellEditor != null && this.tree.isPathEditable(var1)) {
  1210.          int var3 = this.getRowForPath(this.tree, var1);
  1211.          this.editingComponent = this.cellEditor.getTreeCellEditorComponent(this.tree, var1.getLastPathComponent(), this.tree.isPathSelected(var1), this.tree.isExpanded(var1), this.treeModel.isLeaf(var1.getLastPathComponent()), var3);
  1212.          if (this.cellEditor.isCellEditable(var2)) {
  1213.             Rectangle var4 = this.getPathBounds(this.tree, var1);
  1214.             this.editingRow = var3;
  1215.             Dimension var5 = this.editingComponent.getPreferredSize();
  1216.             if (var5.height != var4.height && this.getRowHeight() > 0) {
  1217.                var5.height = this.getRowHeight();
  1218.             }
  1219.  
  1220.             if (var5.width == var4.width && var5.height == var4.height) {
  1221.                this.editorHasDifferentSize = false;
  1222.             } else {
  1223.                this.editorHasDifferentSize = true;
  1224.                this.treeState.invalidatePathBounds(var1);
  1225.                this.updateSize();
  1226.             }
  1227.  
  1228.             this.tree.add(this.editingComponent);
  1229.             this.editingComponent.setBounds(var4.x, var4.y, var5.width, var5.height);
  1230.             this.editingPath = var1;
  1231.             this.editingComponent.validate();
  1232.             Rectangle var6 = this.tree.getVisibleRect();
  1233.             this.tree.paintImmediately(var4.x, var4.y, var6.width + var6.x - var4.x, var5.height);
  1234.             if (this.cellEditor.shouldSelectCell(var2)) {
  1235.                this.stopEditingInCompleteEditing = false;
  1236.  
  1237.                try {
  1238.                   this.tree.setSelectionRow(var3);
  1239.                } catch (Exception var9) {
  1240.                   System.err.println("Editing exception: " + var9);
  1241.                }
  1242.  
  1243.                this.stopEditingInCompleteEditing = true;
  1244.             }
  1245.  
  1246.             if (var2 != null && var2 instanceof MouseEvent) {
  1247.                Point var7 = SwingUtilities.convertPoint(this.tree, new Point(var2.getX(), var2.getY()), this.editingComponent);
  1248.                Component var8 = SwingUtilities.getDeepestComponentAt(this.editingComponent, var7.x, var7.y);
  1249.                if (var8 != null) {
  1250.                   new MouseInputHandler(this, this.tree, var8, var2);
  1251.                }
  1252.             }
  1253.  
  1254.             return true;
  1255.          }
  1256.  
  1257.          this.editingComponent = null;
  1258.       }
  1259.  
  1260.       return false;
  1261.    }
  1262.  
  1263.    public void startEditingAtPath(JTree var1, TreePath var2) {
  1264.       var1.scrollPathToVisible(var2);
  1265.       if (var2 != null && var1.isVisible(var2)) {
  1266.          this.startEditing(var2, (MouseEvent)null);
  1267.       }
  1268.  
  1269.    }
  1270.  
  1271.    public boolean stopEditing(JTree var1) {
  1272.       if (this.editingComponent != null && this.cellEditor.stopCellEditing()) {
  1273.          this.completeEditing(false, false, true);
  1274.          return true;
  1275.       } else {
  1276.          return false;
  1277.       }
  1278.    }
  1279.  
  1280.    protected void toggleExpandState(TreePath var1) {
  1281.       if (!this.tree.isExpanded(var1)) {
  1282.          int var2 = this.getRowForPath(this.tree, var1);
  1283.          this.tree.expandPath(var1);
  1284.          this.updateSize();
  1285.          if (var2 != -1) {
  1286.             if (this.tree.getScrollsOnExpand()) {
  1287.                this.ensureRowsAreVisible(var2, var2 + this.treeState.getVisibleChildCount(var1));
  1288.             } else {
  1289.                this.ensureRowsAreVisible(var2, var2);
  1290.             }
  1291.          }
  1292.       } else {
  1293.          this.tree.collapsePath(var1);
  1294.          this.updateSize();
  1295.       }
  1296.  
  1297.    }
  1298.  
  1299.    protected void uninstallComponents() {
  1300.       if (this.rendererPane != null) {
  1301.          this.tree.remove(this.rendererPane);
  1302.       }
  1303.  
  1304.    }
  1305.  
  1306.    protected void uninstallDefaults() {
  1307.    }
  1308.  
  1309.    protected void uninstallKeyboardActions() {
  1310.       for(int var1 = this.keyActions.size() - 1; var1 >= 0; --var1) {
  1311.          this.tree.unregisterKeyboardAction((KeyStroke)this.keyActions.elementAt(var1));
  1312.       }
  1313.  
  1314.       this.keyActions = null;
  1315.    }
  1316.  
  1317.    protected void uninstallListeners() {
  1318.       if (this.componentListener != null) {
  1319.          this.tree.removeComponentListener(this.componentListener);
  1320.       }
  1321.  
  1322.       if (this.propertyChangeListener != null) {
  1323.          this.tree.removePropertyChangeListener(this.propertyChangeListener);
  1324.       }
  1325.  
  1326.       if (this.mouseListener != null) {
  1327.          this.tree.removeMouseListener(this.mouseListener);
  1328.       }
  1329.  
  1330.       if (this.focusListener != null) {
  1331.          this.tree.removeFocusListener(this.focusListener);
  1332.       }
  1333.  
  1334.       if (this.keyListener != null) {
  1335.          this.tree.removeKeyListener(this.keyListener);
  1336.       }
  1337.  
  1338.       if (this.treeExpansionListener != null) {
  1339.          this.tree.removeTreeExpansionListener(this.treeExpansionListener);
  1340.       }
  1341.  
  1342.       if (this.treeModel != null && this.treeModelListener != null) {
  1343.          this.treeModel.removeTreeModelListener(this.treeModelListener);
  1344.       }
  1345.  
  1346.       if (this.selectionModelPropertyChangeListener != null && this.treeSelectionModel != null) {
  1347.          this.treeSelectionModel.removePropertyChangeListener(this.selectionModelPropertyChangeListener);
  1348.       }
  1349.  
  1350.       if (this.treeSelectionListener != null && this.treeSelectionModel != null) {
  1351.          this.treeSelectionModel.removeTreeSelectionListener(this.treeSelectionListener);
  1352.       }
  1353.  
  1354.    }
  1355.  
  1356.    public void uninstallUI(JComponent var1) {
  1357.       this.completeEditing();
  1358.       this.prepareForUIUninstall();
  1359.       this.uninstallDefaults();
  1360.       this.uninstallListeners();
  1361.       this.uninstallKeyboardActions();
  1362.       this.uninstallComponents();
  1363.       this.completeUIUninstall();
  1364.    }
  1365.  
  1366.    protected void updateCachedPreferredSize() {
  1367.       if (this.treeState != null) {
  1368.          Insets var1 = this.tree.getInsets();
  1369.          if (this.isLargeModel()) {
  1370.             Rectangle var2 = this.tree.getVisibleRect();
  1371.             if (var1 != null) {
  1372.                var2.x -= var1.left;
  1373.                var2.y -= var1.top;
  1374.             }
  1375.  
  1376.             this.preferredSize.width = this.treeState.getPreferredWidth(var2);
  1377.          } else {
  1378.             this.preferredSize.width = this.treeState.getPreferredWidth((Rectangle)null);
  1379.          }
  1380.  
  1381.          this.preferredSize.height = this.treeState.getPreferredHeight();
  1382.          if (var1 != null) {
  1383.             Dimension var10000 = this.preferredSize;
  1384.             var10000.width += var1.left + var1.right;
  1385.             var10000 = this.preferredSize;
  1386.             var10000.height += var1.top + var1.bottom;
  1387.          }
  1388.       }
  1389.  
  1390.       this.validCachedPreferredSize = true;
  1391.    }
  1392.  
  1393.    protected void updateCellEditor() {
  1394.       this.completeEditing();
  1395.       TreeCellEditor var1;
  1396.       if (this.tree == null) {
  1397.          var1 = null;
  1398.       } else if (this.tree.isEditable()) {
  1399.          var1 = this.tree.getCellEditor();
  1400.          if (var1 == null) {
  1401.             var1 = this.createDefaultCellEditor();
  1402.             if (var1 != null) {
  1403.                this.tree.setCellEditor(var1);
  1404.                this.createdCellEditor = true;
  1405.             }
  1406.          }
  1407.       } else {
  1408.          var1 = null;
  1409.       }
  1410.  
  1411.       if (var1 != this.cellEditor) {
  1412.          if (this.cellEditor != null && this.cellEditorListener != null) {
  1413.             this.cellEditor.removeCellEditorListener(this.cellEditorListener);
  1414.          }
  1415.  
  1416.          this.cellEditor = var1;
  1417.          if (this.cellEditorListener == null) {
  1418.             this.cellEditorListener = this.createCellEditorListener();
  1419.          }
  1420.  
  1421.          if (var1 != null && this.cellEditorListener != null) {
  1422.             var1.addCellEditorListener(this.cellEditorListener);
  1423.          }
  1424.  
  1425.          this.createdCellEditor = false;
  1426.       }
  1427.  
  1428.    }
  1429.  
  1430.    protected void updateDepthOffset() {
  1431.       if (this.isRootVisible()) {
  1432.          if (this.getShowsRootHandles()) {
  1433.             this.depthOffset = 1;
  1434.          } else {
  1435.             this.depthOffset = 0;
  1436.          }
  1437.       } else if (!this.getShowsRootHandles()) {
  1438.          this.depthOffset = -1;
  1439.       } else {
  1440.          this.depthOffset = 0;
  1441.       }
  1442.  
  1443.    }
  1444.  
  1445.    protected void updateExpandedDescendants(TreePath var1) {
  1446.       this.completeEditing();
  1447.       if (this.treeState != null) {
  1448.          this.treeState.setExpandedState(var1, true);
  1449.          Enumeration var2 = this.tree.getExpandedDescendants(var1);
  1450.          if (var2 != null) {
  1451.             while(var2.hasMoreElements()) {
  1452.                var1 = (TreePath)var2.nextElement();
  1453.                this.treeState.setExpandedState(var1, true);
  1454.             }
  1455.          }
  1456.  
  1457.          this.updateLeadRow();
  1458.          this.updateSize();
  1459.       }
  1460.  
  1461.    }
  1462.  
  1463.    protected void updateLayoutCacheExpandedNodes() {
  1464.       if (this.treeModel != null) {
  1465.          this.updateExpandedDescendants(new TreePath(this.treeModel.getRoot()));
  1466.       }
  1467.  
  1468.    }
  1469.  
  1470.    private void updateLeadRow() {
  1471.       this.leadRow = this.getRowForPath(this.tree, this.leadPath);
  1472.    }
  1473.  
  1474.    protected void updateRenderer() {
  1475.       if (this.tree != null) {
  1476.          TreeCellRenderer var1 = this.tree.getCellRenderer();
  1477.          if (var1 == null) {
  1478.             this.tree.setCellRenderer(this.createDefaultCellRenderer());
  1479.             this.createdRenderer = true;
  1480.          } else {
  1481.             this.createdRenderer = false;
  1482.             this.currentCellRenderer = var1;
  1483.             if (this.createdCellEditor) {
  1484.                this.tree.setCellEditor((TreeCellEditor)null);
  1485.             }
  1486.          }
  1487.       } else {
  1488.          this.createdRenderer = false;
  1489.          this.currentCellRenderer = null;
  1490.       }
  1491.  
  1492.       this.updateCellEditor();
  1493.    }
  1494.  
  1495.    protected void updateSize() {
  1496.       this.validCachedPreferredSize = false;
  1497.       this.tree.treeDidChange();
  1498.    }
  1499. }
  1500.